package com.myproject.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

/**
 * JSON处理工具类
 * 
 * <p>提供常用的JSON操作方法，包括对象与JSON字符串之间的转换，
 * 以及JSON字符串的格式化等。</p>
 * 
 * <p>使用Jackson库实现，线程安全。</p>
 */
public class JsonUtils {

    private static final ObjectMapper mapper = new ObjectMapper();

    static {
        // 注册Java 8时间模块
        mapper.registerModule(new JavaTimeModule());
        // 禁用日期作为时间戳
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        // 美化输出
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
    }

    private JsonUtils() {
        // 私有构造方法防止实例化
    }

    /**
     * 将对象转换为JSON字符串
     * @param obj 要转换的对象
     * @return JSON字符串
     * @throws JsonProcessingException 如果转换过程中发生错误
     */
    public static String toJson(Object obj) throws JsonProcessingException {
        return mapper.writeValueAsString(obj);
    }

    /**
     * 将对象转换为JSON字符串（不抛出异常）
     * @param obj 要转换的对象
     * @return JSON字符串，转换失败返回null
     */
    public static String toJsonSafe(Object obj) {
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            return null;
        }
    }

    /**
     * 将JSON字符串转换为指定类型的对象
     * @param json JSON字符串
     * @param clazz 目标类型
     * @param <T> 泛型类型
     * @return 转换后的对象
     * @throws JsonProcessingException 如果转换过程中发生错误
     */
    public static <T> T fromJson(String json, Class<T> clazz) throws JsonProcessingException {
        return mapper.readValue(json, clazz);
    }

    /**
     * 将JSON字符串转换为指定类型的对象（不抛出异常）
     * @param json JSON字符串
     * @param clazz 目标类型
     * @param <T> 泛型类型
     * @return 转换后的对象，转换失败返回null
     */
    public static <T> T fromJsonSafe(String json, Class<T> clazz) {
        try {
            return mapper.readValue(json, clazz);
        } catch (JsonProcessingException e) {
            return null;
        }
    }

    /**
     * 将JSON字符串转换为复杂类型对象（支持泛型）
     * @param json JSON字符串
     * @param typeReference 类型引用，用于处理泛型
     * @param <T> 泛型类型
     * @return 转换后的对象
     * @throws JsonProcessingException 如果转换过程中发生错误
     */
    public static <T> T fromJson(String json, TypeReference<T> typeReference) throws JsonProcessingException {
        return mapper.readValue(json, typeReference);
    }

    /**
     * 格式化JSON字符串
     * @param json 原始JSON字符串
     * @return 格式化后的JSON字符串
     * @throws JsonProcessingException 如果JSON格式不正确
     */
    public static String formatJson(String json) throws JsonProcessingException {
        Object obj = mapper.readValue(json, Object.class);
        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    }

    /**
     * 检查字符串是否为有效的JSON
     * @param json 要检查的字符串
     * @return 如果是有效JSON返回true，否则返回false
     */
    public static boolean isValidJson(String json) {
        try {
            mapper.readTree(json);
            return true;
        } catch (JsonProcessingException e) {
            return false;
        }
    }
}